55.6 KB · ⇊ 16 parts · ⤓ Micron 55.6 KB · ⤓ HTML 94.4 KB

layout: Wide · Narrow · Centered

top

C# (C sharp [siː.ʃɑːp] en anglais britannique) est un langage de programmation orientée objet, commercialisé par Microsoft depuis 2002cite-ref-tata-2-0[2] et destiné à développer sur la plateforme Microsoft .NET, au même titre que d’autres langages liés à cette plateforme (ex. : VB .NET, J#, etc.).

C# est dérivé du C++ et très proche du Java dont il reprend la syntaxe générale ainsi que les concepts, y ajoutant des notions telles que la surcharge des opérateurs, les indexeurs (en) et les délégués. Il est utilisé notamment pour développer des applications web sur la plateforme ASP.NET, ainsi que des jeux vidéo avec les moteurs de jeux Unity et Godotcite-ref-3[3].

• Présentation

• Plateforme .NET

• Caractéristiques

• Syntaxe

• Différences avec le C++

• Différences avec le Java

• Histoire

• Versions

• C# 2.0

• C# 3.0

• C# 4.0

• C# 5.0

• C# 6.0

• C# 7.0

• C# 8.0

• C# 9.0

• C# 10.0

• C# 11.0

• C# 12.0

• C# 13.0

• Standardisation

• Nom du langage

• Voir aussi

• Annexes

• Liens externes

• Bibliographie

• Notes et références

C# est un langage de programmation orientée objet, fortement typé, dérivé de C et de C++, ressemblant au langage Javacite-ref-tata-2-1[2]. Il est utilisé pour développer des applications web, ainsi que des applications de bureau, des services web, des commandes, des widgets ou des bibliothèques de classescite-ref-tata-2-2[2]. En C#, une application est un lot de classes où une des classes comporte une méthode Main, comme cela se fait en Javacite-ref-tata-2-3[2].

C# est destiné à développer sur la plateforme .NET, une pile technologique créée par Microsoft pour succéder à COM.

Les exécutables en C# sont subdivisés en assemblies, en namespaces, en classes et en membres de classecite-ref-addison-4-0[4]. Un assembly est la forme compilée, qui peut être un programme (un exécutable) ou une bibliothèque de classes (une dll). Un assembly contient le code exécutable en MSIL, ainsi que les symboles. Le code MSIL est traduit en langage machine au moment de l'exécution par la fonction just-in-time de la plateforme .NETcite-ref-addison-4-1[4].

C# est destiné à développer sur la plateforme .NET. Le cœur de cette pile technologique est le framework .NET, composé decite-ref-tata-2-4[2] :

• les environnements ASP.NET et Winforms (qui servent à exécuter respectivement des applications web et de bureau) conçus pour la plateforme .NETcite-ref-tata-2-5[2] ;

• une bibliothèque de classes qui permet de manipuler des fichiers, manipuler des tableaux ou des structures en arbres, accéder à Internet, créer des interfaces graphiques, accéder à des bases de données, accéder au registre Windows et beaucoup d'autres choses. La plupart des fonctionnalités sont offertes par des classes de l'espace de noms Systemcite-ref-tata-2-6[2] ;

• le Common Language Runtime (abr. CLR) est le runtime utilisé par les langages de la plateforme .NET (C#, Visual Basic .NET, J#, etc.), les services fournis par la CLR sont le lancement et l'exécution de programmes, le ramasse-miettes et la gestion d'exceptions. Un programme pour la plateforme .NET est tout d'abord compilé en une forme intermédiaire, le MSIL, puis ce code MSIL est transformé en code machine qui sera exécuté par la CLR. Ce code machine est appelé managed code parce que son exécution est sous le contrôle de la CLRcite-ref-tata-2-7[2].

Un autre produit de la plateforme .NET est l'environnement de développement Visual Studio .NET, outil généralement utilisé pour programmer en C#cite-ref-tata-2-8[2].

C# est un langage dérivé du C++, il apporte un typage sûr, ainsi que les possibilités d'encapsulation, d'héritage et de polymorphisme des langages orientés objetcite-ref-tata-2-9[2]. En C# tous les types sont des objetscite-ref-tata-2-10[2]. Le langage comporte un ramasse-miettes et un système de gestion d'exceptionscite-ref-tata-2-11[2].

Le typage sûr signifie notamment que les opérations suivantes sont refusées : utilisation de variable non initialisée, tentative d'accéder au-delà des limites d'un tableau, conversions de type dont les résultats ne sont pas prévisibles, dépassement des limites lors d'opérations arithmétiquescite-ref-tata-2-12[2].

Beaucoup de possibilités de Java se retrouvent dans C# et il y a une forte ressemblance entre un code écrit en C# et le code équivalent en Javacite-ref-tata-2-13[2].

En C# les variables peuvent être d'un type valeur ou d'un type référence. Les types valeur sont les types primitifs, les énumérations, les struct et les types nullablecite-ref-addison-4-2[4]. Les types référence sont les classes, les interfaces, les tableaux et les delegatecite-ref-addison-4-3[4].

Les types primitifs sont sbyte, short, int, long, byte, ushort, uint, ulong, char, float, double, decimal et boolcite-ref-addison-4-4[4].

Les constructions les plus fondamentales du langage C# sont les classes. Celles-ci peuvent contenir des constantes, des champs, des propriétés, des indexeurs, des méthodes, des événements, des opérateurs, des constructeurs, des destructeurs ou des sous-classescite-ref-addison-4-5[4]. Les classes élémentaires sont string et objectcite-ref-addison-4-6[4].

Les struct sont similaires aux classes, mais ce sont des types valeurs et ils ne peuvent pas être héritéscite-ref-addison-4-7[4].

Un delegate est une référence à une méthode qui comporte certains paramètres. Les delegates permettent d'assigner des méthodes à des variables et les passer en paramètrecite-ref-addison-4-8[4].

Un type énuméré est un type valeur qui comporte un lot de constantes. Chaque type énuméré a un type sous-jacent : un type primitif déterminé en fonction des valeurs des constantes.

Les nullable sont des types primitifs qui peuvent en plus avoir la valeur nullcite-ref-addison-4-9[4]. Chaque type primitif T a un type nullable associé T?. Par exemple une variable de type int? peut contenir un int ou nullcite-ref-addison-4-10[4].

Exemple de code :

Les mots clé de C# 1.0 sont :

cite-ref-essential-5-0[5]

Les mots clés ajoutés entre C# 2.0 et 6.0 :

cite-ref-essential-5-1[5]

La syntaxe de C# permet de réaliser des chaînes de caractères numériques dont le format est modifiablecite-ref-6[6], notamment avec TimeSpan pour la réalisation de chronomètre ou minuteurcite-ref-7[7].

Le langage compte un certain nombre de changements par rapport au C/C++ ; on notera particulièrement les points suivants :

• la manipulation directe de pointeurs ne peut se faire qu’au sein d’un code marqué unsafe, et seuls les programmes avec les permissions appropriées peuvent exécuter des blocs de code unsafe. La plupart des manipulations de pointeurs se font via des références sécurisées, dont l’adresse ne peut être directement modifiée, et la plupart des opérations de pointeurs et d’allocations sont contrôlées contre les dépassements de mémoire. Les pointeurs ne peuvent pointer que sur des types de valeurs, les types objets, manipulés par le ramasse-miettes, ne pouvant qu’être référencés ;

• les objets ne peuvent pas être explicitement détruits. Le ramasse-miettes s’occupe de libérer la mémoire lorsqu’il n’existe plus aucune référence pointant sur un objet. Toutefois, pour les objets gérant des types non managés, il est possible d’implémenter l’interface IDisposable pour spécifier des traitements à effectuer au moment de la libération de la ressource ;

• l’héritage multiple de classes est interdit, mais une classe peut implémenter un nombre illimité d’interfaces, et une interface peut hériter de plusieurs interfaces ;

• le C# est beaucoup plus typé que le C++ ; les seules conversions implicites sont celles entre les différentes gammes d’entiers et celles d’un type dérivé à un type parent. Aucune conversion implicite n’a lieu entre booléens et entiers, entre membres d’énumération et entiers, ni de pointeurs sur un type void (quoique pour ce dernier point l’utilisation de références sur le type Object permette d’obtenir le même effet). Les conversions définies par l’utilisateur peuvent être définies comme implicites ou explicites ;

• la syntaxe pour la déclaration des tableaux n’est pas la même : int[] a = new int[5] remplace int a[5]. Car il s'agit d'une allocation dynamique, int[] a étant la déclaration d'une référence (nulle si non initialisée). L'allocation manuelle d'un tableau sur la pile reste cependant possible avec le mot clé stackalloccite-ref-8[8] ;

• les membres d’une énumération sont rassemblés dans leur propre espace de noms ;

• le C# ne gère pas les templates, mais cette fonctionnalité a été remplacée par les types génériques apparus avec C# 2.0 ;

• les propriétés ont été introduites, et proposent une syntaxe spécifique pour l’accès aux données membres (ainsi que la facilitation de l’accès simultané par plusieurs threads) ;

• la réflexion totale des types est disponible ;

• les délégués, qui sont des listes de pointeurs sur fonctions, sont utilisés notamment pour la programmation événementielle.

Bien que le C# soit similaire à Java, il existe des différences notables, par exemple :

• Java n'autorise pas la surcharge des opérateurs ;

• Java a des exceptions vérifiées, alors que les exceptions du C# ne sont pas vérifiées, comme en C++ ;

• Java permet la génération automatique de la documentation HTML à partir des fichiers sources à l'aide des descriptions Javadoc-syntax, tandis que le C# utilise des descriptions fondées sur le XML ;

• Java n'a pas de langage préprocesseur ;

• C# prend en charge les indexeurs, les méthodes déléguées, et les événements (là où Java se contente du patron de conception observateur) ;

• C# ne prend pas en charge les implémentations anonymes d'interfaces et de classes abstraites ;

• C# ne prend en charge que les classes internes statiques ;

• C# prend en charge les structures en plus des classes (les structures sont des types valeur : on stocke le contenu et non l'adresse) ;

• C# utilise une syntaxe intégrée au langage (DllImportcite-ref-9[9]) et portable pour appeler une bibliothèque native, tandis que Java utilise Java Native Interface ;

• C# intègre la généricité et la machine .NET a été modifiée pour permettre cela (Java l'intègre également, mais son implémentation a été réalisée dans le compilateur javac sans changer le bytecode Java)cite-ref-10[10].

C'est en septembre 2002 que la plateforme .NET et C# sont présentés au publiccite-ref-tata-2-14[2]. C# devient le langage de facto de cette plateforme, il a par ailleurs été utilisé pour implémenter une partie de la plateforme .NETcite-ref-tata-2-15[2].

| Année | Version | Bibliothèque |

|---|---|---|

| 2002 | 1.0 | .NET framework 1.0 et 1.1 |

| 2005 | 2.0 | .NET framework 2.0 |

| 2008 | 3.0 | .NET framework 3.5 |

| 2010 | 4.0 | .NET framework 4.0 |

| 2012 | 5.0 | .NET framework 4.5 |

| 2015 | 6.0 | .NET framework 4.6 |

| 2017 | 7.0 - 7.3 | .NET framework >= 4.5 et .NET Core 2.X |

| 2019 | 8.0 | .NET standard >=2.1 et .NET Core >=3.0 |

| 2020 | 9.0 | .NET 5.0 |

| 2021 | 10.0 | .NET 6.0 |

| 2022 | 11.0 | .NET 7.0 |

| 2023 | 12.0 | .NET 8.0 |

| 2024 | 13.0 | .NET 9.0 |

| Année | Principal changement |

|---|---|

| 2005 | généricité ajoutée à C# et au framework |

| 2008 | LINQ ( L anguage IN tegrated Q ueries) |

| 2010 | types dynamiques |

| 2012 | méthodes asynchrones |

| 2015 | version pour Linux |

| 2017 | Tuples , fonctions locales |

| 2019 | Membre ReadOnly, opérateur d’assignatio… |

| 2020 | Vérification de nullité, instructions d… |

| 2021 | Directives d’utilisation globale, modèl… |

| 2022 | Attributs générique, membre requis, cha… |

| 2023 | Simplification de code |

| 2024 | Amélioration param, lock |

cite-ref-essential-5-2[5]

Microsoft mit à disposition du public en octobre 2005, après une longue période de beta-tests, la version 2.0 de la bibliothèque .NET, accompagnée d’une nouvelle version de la quasi-totalité des outils associés. C# ne fait pas exception à la règle et sort donc en version 2.0, avec les ajouts suivants :

• les classes partielles, permettant de répartir l’implémentation d’une classe sur plusieurs fichiers ;

• les types génériques, qui ne sont pas une simple copie des templates C++. Par exemple, on trouvera dans les génériques C# la restriction de types (pour spécifier les types utilisables dans une généralisation). Par contre, il est impossible d’utiliser des expressions comme paramètres pour la généralisation ;

• un nouvel itérateur qui permet l’utilisation de coroutines via le mot-clé yield, équivalent du yield que l’on trouve en Python ;

• les méthodes anonymes avec des règles de fermeture configurables ;

• les types « nullables », c'est-à-dire la possibilité de spécifier qu’un type de valeur peut être nul. Ceux-ci sont déclarés avec le caractère point d'interrogation « ? » suivant le nom du type, comme ceci : int? i = null;

• le nouvel opérateur double point d'interrogation « ?? » utilise deux opérandes et retourne le premier non nul. Il a été introduit pour spécifier une valeur par défaut pour les types « nullables ».

À titre de référence, les spécifications complètes des nouveautés introduites dans la version 2.0 sont disponibles dans les liens externes.

La fonctionnalité des types nullables fut corrigée quelques semaines seulement avant la sortie publique de la version 2.0, car il a été mis en lumière que si la valeur de la variable était bien nulle, cette variable n’était pas nulle au sens traditionnel du terme, c'est-à-dire qu’il ne s’agit pas d’une référence vide. Ainsi, la conversion d’un type primitif de valeur nulle en objet donnait une référence non nulle vers une valeur nulle. Il fallut donc, pour corriger ce problème, corriger le noyau du CLR et effectuer de nombreuses vérifications et corrections sur tous les produits de la gamme .NET 2.0 (Visual Studio 2005, SQL Server 2005, C# et VB.NET).

Le C# 3.0 fut présenté au salon Processing Community Daycite-ref-11[11] 2005. La version finale est disponible depuis le 19 novembre 2007 au téléchargement sur le site de Microsoft]cite-ref-12[12]. Les principales nouveautés sont les suivantes :

• L’ajout des mots-clefs select, from et where pour permettre la formation et l’exécution de requêtes SQL, XML, ou directement sur des collections. Cette fonctionnalité fait partie du programme Language Integrated Query (LINQ)]cite-ref-13[13].

• Nouvelle possibilité d’initialisation d'un objet : À la place de Client c = new Client(); c.Nom = "Dupont";, on peut utiliser Client c = new Client{ Nom = "Dupont" };

• Expressions lambda : ListeTrucs.Where( delegate(Truc x) { return x.Size > 10; } ); devient ListeTrucs.Where( x => x.Size > 10 );

• Inférence du type des variables locales : string s = "Dupont" peut être remplacé par var s = "Dupont"

• Introduction des types anonymes : var x = new { Nom = "Dupont" } peut être utilisé à la place de class __anonymous { private string _nom; public string Nom { get { return _nom; } set { _nom = value; } } } __anonymous x = new __anonymous(); x.Nom = "Dupont";

• Les arbres d'expressions (expression treescite-ref-14[14]) : permettent la compilation du code sous forme d'arbres d'objets facilement analysables et manipulables.

• Méthodes étendues : permet d'ajouter des méthodes à une classe en y ajoutant un premier paramètre this.

Une présentation du C# 3.0 et de LINQ peut être trouvée sur la page du centre de développement de .NET Framework.

Le code compilé en C# 3.0 est entièrement compatible avec celui du 2.0, étant donné que les améliorations apportées ne sont que purement syntaxiques ou ne consistent qu’en des raccourcis compensés au moment de la compilation. Les nouveautés introduites dans les bibliothèques de la version 3.5 (LINQ, etc.) ne sont cependant pas utilisables avec les versions précédentes de C#.

Cette version exige Windows XP ou une version supérieure (Vista ou Windows 7). Elle n'est pas disponible pour Windows 2000.

La version 4 du langage apporte plusieurs nouveautés :

• le typage dynamique des variables à l'aide du mot clé dynamic ;

• les arguments nommés et facultatifscite-ref-15[15] ;

• la prise en charge de la covariance et de la contravariance (en) pour les interfaces et les délégués génériques.

Le framework .NET 4.0 est sorti le 12 avril 2010, accompagné de Visual Studio 2010cite-ref-16[16]. Il propose entre autres :

• la nouvelle bibliothèque parallèle : Task Parallel Librarycite-ref-17[17] ;

• une version optimisée de la plate-forme entité d'accès aux bases de données (Entity Framework) via l'utilisation de LINQ ;

• la version parallèle de LINQ appelée PLINQcite-ref-18[18].

La version 5 du langage permet de programmer plus simplement des programmes asynchrones grâce à l'ajout des mots clés async et await.

Le comportement des closures dans la boucle foreach (en) a été modifié. Il n'est désormais plus nécessaire d'introduire une variable locale dans une boucle foreach pour éviter les problèmes de closurecite-ref-19[19].

À noter également les informations relatives à l'appelantcite-ref-20[20] permettant de connaître le nom de la méthode qui a appelé une propriété.

La sixième version du C# apporte plusieurs modifications, notamment :

Les propriétés implémentées automatiquement (ou propriétés automatiques) sont apparues en C# 3, pour simplifier la déclaration de propriétés qui se contentent d'encapsuler l'accès à des champs. Bien qu'elles permettent de rendre le code plus concis, elles présentent un inconvénient : il n'est pas possible de les initialiser au niveau de la déclaration, il faut forcément le faire dans le constructeur. De plus, il n'est pas possible de faire des propriétés automatiques en lecture seule, puisqu'elles n'ont pas de mutateur (setter) et on ne pourrait donc pas leur affecter de valeur.

C# 6 remédie à ce problème en permettant d'initialiser les propriétés automatiques au niveau de la déclarationcite-ref-21[21].

La version 7 du langage apporte de nombreuses nouveautés dont les principales sontcite-ref-22[22]:

• Les fonctions locales: la possibilité de déclarer une méthode à l'intérieur dans une autre méthode

• Tuples et déconstruction: cela permet par exemple pour une fonction, de renvoyer plusieurs valeurs

• Variables out: une variable peut être déclaré au moment de l'appel. Par exemple: int.TryParse(s, out int i);

• Pattern matching (ou filtrage par motif en français) permet de déterminer si une valeur correspond à un motif donné. Exemple avec un switch: cite-ref-23[23]switch (shape) { case Rectangle r: Console.WriteLine($"Rectangle with area {r.Width * r.Height}"); break; case Circle c when c.Radius < 5: Console.WriteLine($"Small circle"); break; case Circle c: Console.WriteLine($"Large circle"); break; }

• Membres expression-bodied étendus

• Amélioration des littéraux numériques

• Retours par référence

La version 8 de C# est la première qui cible spécifiquement .NET Core.

Quelques nouveautés:

• les fonction locales statiquescite-ref-fonctionnalit-s-c-8-0-24-0[24]

• l'utilisation de using sans bloc de codecite-ref-fonctionnalit-s-c-8-0-24-1[24]:

• méthode d’interface par défaut

• membre de structure readonlycite-ref-25[25]

• opérateur ??= : affecte une valeur uniquement si la variable est nullecite-ref-26[26]

• index et plage d’une liste

La version 9 de C# comprend entre autre les nouveautés suivantescite-ref-27[27]:

• les records

• l'accesseur init

• new(): omission possible du type

• les fonctions anonymes statiques

• la simplification du code de la fonction Main()

• le support de la méthode d’extension GetEnumerator() pour les boucles foreach

La version 10 de C# comprend entre autre les nouveautés suivantescite-ref-28[28]:

• simplification de la déclaration des namespaces, à la portée du fichier

• amélioration du pattern matching

• amélioration des expressions lambda

• amélioration des records (introduits avec C# 9)

• namespaces implicites (déclaré au niveau du projet plutôt que dans chaque fichier)

Les principales nouveautés de la version 11 sontcite-ref-29[29]:

• les propriétés required qui doivent être obligatoirement initialisées

• les littéraux de chaîne bruts. Ces chaînes commencent et se terminent par trois guillemets (""")

• les listes patterns

• le mot clé file pour la déclaration de type

La version 12 de C# comprend les nouveautés suivantescite-ref-30[30]:

• simplification de code pour la création des collections, comme par exemple: List<int> items1 = [1, 2, 3, 4];

• les constructeurs primaires sur les classes ou les structures. Exemple: public class Rectangle(int length, int width);

• l'opérateur spread, pour créer une collection à partir d'un énumérable. Exemple: List<int> collection1 = [..array1];

• ref only en argument de méthode

La version 13 de C#, introduite avec .Net 9, comprend les nouveautés suivantescite-ref-31[31]:

• collections params: le mot clé fonctionne avec C# 13 avec tout type de collection

• nouvel objet pour la synchronisation de thread: System.Threading.Lock

• index à partir de la fin dans les initialisateurs de collection. Par exemple:Value[^1] = 999;

• propriétés partielles et indexeurs partiels

Le C# a été normalisé par l'ECMA (ECMA-334) en décembre 2001 et par l'ISO/CEI (ISO/CEI 23270) en 2003.

Les modifications survenues dans la Version 2.0 ont été normalisées par l'ECMA (ECMA-334) en juin 2006 et par l'ISO/CEI (ISO/CEI 23270:2006) en septembre 2006.

Microsoft a ouvert le code source de certaines bibliothèques utilisées par le C# en octobre 2007 sous la licence Microsoft Reference Source License (MS-RSL)cite-ref-32[32].

Le standard ECMA 334 et l'ISO 23270 définissent le nom du langage comme le caractère Unicode 0043 (C majuscule) suivi du caractère 0023 (#)cite-ref-33[33]. Il est prononcé « C sharp » et non « C hash », « sharp » désignant en effet le symbole musical ♯ mais # étant nécessaire pour un accès facile depuis un clavier d'ordinateur qui propose le croisillon (« hash ») à la place.

Le nom "C#" est inspiré de la notation musicale où un dièse indique que la note écrite doit être augmentée d'un demi-ton. Ceci est similaire au nom de langage de C++, où "++" indique qu'une variable doit être incrémentée de 1 après avoir été évaluée. Le symbole # ressemble également à une ligature de quatre symboles "+" (dans une grille deux par deux), ce qui implique que le langage est un incrément de C++[réf. souhaitée].

• C++

• Microsoft .NET

• Visual Studio

• Roslyn (compilateur) (en)

• site-officielDocumentation C# – Démarrage, tutoriels et informations de référence | Microsoft Docs

• Notice dans un dictionnaire ou une encyclopédie généraliste : Store norske leksikon

• Notices d'autorité : BnF (données) LCCN GND Israël Tchéquie

• (en) Page du standard ISO/CEI 23270:2006

• (en) Page du standard ECMA 334

• Centre de Développement C# - Site MSDN

• C# et .NET - Gérard Leblanc - 2002 - Éditions Eyrolles - (ISBN 2-212-11066-9)

• C# et .NET Version 2 - Gérard Leblanc - 2006 - Éditions Eyrolles - (ISBN 2-212-11778-7)

• C# Tête la première - Andrew Stellman, Jennifer Greene - 2008 - Éditions Digit Books - (ISBN 978-2-81500-001-7)

• Introduction à C# - Pierre-Yves Saumont, Antoine Mirecourt - 2001 - Éditions Eyrolles - (ISBN 2-7464-0301-3)

• Le guide de survie C# - Gilles Tourreau - 2010 - Éditions Pearson Education - (ISBN 978-2-7440-2432-0)

• (en) C# 2005 Programmer's Reference - Adrian Kingsley-Hughes, Kathie Kingsley-Hughes - 2006 - Édition Wrox - (ISBN 0-470-04641-4)

• (en) C# Essentials, 2nd Edition - Ben Albahari, Peter Drayton, Brad Merrill - 2002 - Édition O'Reilly Media - (ISBN 0-596-00315-3)

• (en) Professional C#, 3rd Edition - Simon Robinson, Christian Nagel, Karli Watson, Jay Glynn, Morgan Skinner, Bill Evjen - 2004 - Édition Wrox - (ISBN 0-7645-5759-9)

cite-note-wikidata-5d8d057790c69ac436273957122243a1f695f7bd-11. « What's new in .NET 10 »

cite-note-tata-22. (en) Balagurusamy, Programming In C#, Tata McGraw-Hill Education - 2008, (ISBN 9780070667570).

cite-note-33. ↑ neowin-2024paul-hill-neowin-2024(en) Paul Hill Neowin ·, « Godot Engine arrives on Epic Games Store making it easier to download », sur Neowin, 9 mars 2024 (consulté le 9 mars 2024).

cite-note-addison-44. (en) Anders Hejlsberg - Mads Torgersen - Scott Wiltamuth - Peter Golde, The C# Programming Language (Covering C# 4.0), Portable Documents, Addison-Wesley Professional - 2010, (ISBN 9780132481724).

cite-note-essential-55. (en) Mark Michaelis - Eric Lippert, Essential C# 6.0, Addison-Wesley Professional - 2015, (ISBN 9780134176130).

cite-note-66. ↑ (en) « Custom numeric format strings », sur microsoft.com (consulté le 21 avril 2023).

cite-note-77. ↑ (en) « Custom TimeSpan format strings », sur microsoft.com (consulté le 21 avril 2023).

cite-note-88. ↑ Site MSDN

cite-note-99. ↑ learn2023microsoft-learn2023(en) Microsoft Learn, « DllImportAttribute Class (System.Runtime.InteropServices) », sur Microsoft Learn, 16 mai 2023 (consulté le 31 janvier 2025).

cite-note-1010. ↑ (en) Support du cours de sous-typage du MPRI[PDF], diapositives 73-80 et 70-89.

cite-note-1111. ↑ foundationprocessing-foundation(en) Processing Foundation, « Processing Foundation — Processing Community Day @ Worldwide », sur Processing Foundation (consulté le 31 janvier 2025).

cite-note-1212. ↑ (en) https://msdn2.microsoft.com/en-us/vstudio/default.aspx

cite-note-1313. ↑ (en) https://msdn2.microsoft.com/fr-fr/netframework/aa904594.aspx

cite-note-1414. ↑ learn2024microsoft-learn2024(en) Microsoft Learn, « Expression Trees - C#, Microsoft Learn », sur Microsoft Learn, 29 mai 2024 (consulté le 31 janvier 2025).

cite-note-1515. ↑ https://msdn.microsoft.com/fr-fr/library/vstudio/dd264739(v=vs.100).aspx

cite-note-1616. ↑ (en) Site MSDN.

cite-note-1717. ↑ learn2022microsoft-learn2022(en) Microsoft Learn, « Task Parallel Library (TPL) - .NET, Microsoft Learn », sur Microsoft Learn, 1er août 2022 (consulté le 31 janvier 2025).

cite-note-1818. ↑ learn2017microsoft-learn2017(en) Microsoft Learn, « Introduction to PLINQ - .NET, Microsoft Learn », sur Microsoft Learn, 30 mars 2017 (consulté le 31 janvier 2025).

cite-note-1919. ↑ http://blogs.msdn.com/b/ericlippert/archive/2009/11/12/closing-over-the-loop-variable-considered-harmful.aspx

cite-note-2020. ↑ https://msdn.microsoft.com/fr-fr/library/hh534540.aspx

cite-note-2121. ↑ levesquethomas-levesqueThomas Levesque, « Les nouveautés de C# 6 » (consulté le 19 septembre 2015).

cite-note-2222. ↑ levesque2016thomas-levesque2016Thomas Levesque, « Les nouveautés de C# 7 », Developpez.com,‎ 24 novembre 2016 (lire en ligne, consulté le 17 octobre 2025)

cite-note-2323. ↑ montantin2020mathias-montantin2020Mathias Montantin, « Pattern matching (C# 7, C# 8.0) », sur Blog .NET, 17 octobre 2020 (consulté le 17 octobre 2025)

cite-note-fonctionnalit-s-c-8-0-2424. montantin2021mathias-montantin2021Mathias Montantin, « Fonctionnalités C# 8.0 », sur Blog .NET, 6 février 2021 (consulté le 17 octobre 2025)

cite-note-2525. ↑ montantin2020mathias-montantin2020Mathias Montantin, « Membre d'une structure en lecture seule avec readonly (C# 8.0) », sur Blog .NET, 19 décembre 2020 (consulté le 17 octobre 2025)

cite-note-2626. ↑ montantin2020mathias-montantin2020Mathias Montantin, « Références nullables (C# 8.0) », sur Blog .NET, 26 décembre 2020 (consulté le 17 octobre 2025)

cite-note-2727. ↑ montantin2021mathias-montantin2021Mathias Montantin, « Les fonctionnalités C# 9.0 », sur Blog .NET, 31 décembre 2021 (consulté le 20 octobre 2025)

cite-note-2828. ↑ montantin2023mathias-montantin2023Mathias Montantin, « Les fonctionnalités C# 10.0 », sur Blog .NET, 30 décembre 2023 (consulté le 20 octobre 2025)

cite-note-2929. ↑ « Les nouveautés de C# 11 - Invivoo », sur invivoo.com (consulté le 20 octobre 2025)

cite-note-3030. ↑ montantin2025mathias-montantin2025Mathias Montantin, « Les fonctionnalités C# 12 », sur Blog .NET, 16 août 2025 (consulté le 29 octobre 2025).

cite-note-3131. ↑ bourennane2024abdelkrim-bourennane2024Abdelkrim Bourennane, « Les nouveautés .NET 9 et C# 13 avec des exemples », sur Le blog de Cellenza, 10 décembre 2024 (consulté le 29 octobre 2025)

cite-note-3232. ↑ Microsoft Reference Source License (MS-RSL)

cite-note-3333. ↑ ECMA 334, p. 11

• Portail de Microsoft

• Portail de la programmation informatique

• Portail de l’informatique